DBGen User Manual

DBGen is a tool for Coq developers. It takes as input the definition of a term structure with bindings annotations and generates definitions and properties for lifting and substitution in the De Bruijn setting, up to the substitution lemma. It provides also a named syntax and a translation function to the De Bruijn syntax

LoopW Technical Reference v0.3

This document describes the implementation in SML of the LoopW language, an imperative language with higher-order procedural variables and non-local jumps equiped with a program logic. It includes the user manual along with some implementation notes and many examples of certified imperative programs. As a concluding example, we show the certification of an imperative program encoding shift/reset using callcc/throw and a global meta-continuation

A Formally Specified Type System and Operational Semantics for Higher-Order Procedural Variables

We formally specified the type system and operational semantics of LOOPw with Ott and Isabelle/HOL proof assistant. Moreover, both the type system and the semantics of LOOPw have been tested using Isabelle/HOL program extraction facility for inductively defined relations. In particular, the program that computes the Ackermann function type checks and behaves as expected. The main difference (apart from the choice of an Ada-like concrete syntax) with LOOPw comes from the treatment of parameter passing. Indeed, since Ott does not currently fully support alpha-conversion, we rephrased the operational semantics with explicit aliasing in order to implement the out parameter passing mode

Generic Environments in Coq

We introduce a library which provides an abstract data type of environments, as a functor parameterized by a module defining variables, and a function which builds environments for such variables with any Type of type. Usual operations over environments are defined, along with an extensive set of basic and more advanced properties. Moreover, we give an implementation using lists satisfying all the required properties.Comment: 6 pages; The Third Coq Workshop (Coq'3), 201

A program logic for higher-order procedural variables and non-local jumps

Relying on the formulae-as-types paradigm for classical logic, we define a program logic for an imperative language with higher-order procedural variables and non-local jumps. Then, we show how to derive a sound program logic for this programming language. As a by-product, we obtain a non-dependent type system which is more permissive than what is usually found in statically typed imperative languages. As a generic example, we encode imperative versions of delimited continuations operators shift and reset

Deriving a Hoare-Floyd logic for non-local jumps from a formulae-as-types notion of control

We derive a Hoare-Floyd logic for non-local jumps and mutable higher-order procedural variables from a formul{\ae}-as-types notion of control for classical logic. The main contribution of this work is the design of an imperative dependent type system for non-local jumps which corresponds to classical logic but where the famous consequence rule is still derivable.Comment: The 22nd Nordic Workshop on Programming Theory, Turku : Finland (2010

Deriving SN from PSN: a general proof technique

Technical report of the LACL, TR-LACL-2006-5In the framework of explicit substitutions there is two termination properties: preservation of strong normalization (PSN), and strong normalization (SN). Since there are not easily proved, only one of them is usually established (and sometimes none). We propose here a connection between them which helps to get SN when one already has PSN. For this purpose, we formalize a general proof technique of SN which consists in expanding substitutions into "pure" lambda-terms and to inherit SN of the whole calculus by SN of the "pure" calculus and by PSN. We apply it successfully to a large set of calculi with explicit substitutions, allowing us to establish SN, or, at least, to trace back the failure of SN to that of PSN